/* 
 * Assert.java
 * 
 * Data de criação: 09/04/2010
 * 
 * CORPORATIVO - MTE. 
 *
 */
package br.com.o2solutions.util.assertion;

import java.util.Collection;
import java.util.Map;

/**
 * 
 * Classe responsável por realizar a Assertiva de operações para auxiliar na
 * validação de Argumentos. Opera de forma parecida com a implementação de
 * Assertivas de teste, porém, pode ser utilizada para lançamento de exceções
 * relacionadas a aplicação de regras negociais. Utiliza com classe base a
 * classe de assertivas {@link org.springframework.util.Assert}.
 * 
 * @author osvaldeir
 * @since 12/05/2010
 * 
 */
public abstract class Assert {

	/**
	 * Verifica se a expressao boleana e verdadeira e, caso contrário, lanca a
	 * excecao parametrizada.
	 * 
	 * @param expression
	 *            Expressao boleana
	 * @param exceptionToLaunch
	 *            Excecao a ser lancada pela chamada
	 * @throws RuntimeException
	 *             Caso a expressao boleana seja false.
	 */
	public static void isTrue(Boolean expression,
			RuntimeException exceptionToLaunch) throws RuntimeException {
		try {
			org.springframework.util.Assert.isTrue(expression);
		} catch (Exception e) {
			throw exceptionToLaunch;
		}
	}

	/**
	 * Verifica se a expressao e verdadeira e, caso contrario, lanca uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param expression
	 *            condicao a ser verificada quanto sua afirmacao (true).
	 */
	public static void isTrue(Boolean expression) {
		org.springframework.util.Assert.isTrue(expression);
	}

	/**
	 * Veridica se a expressao e verdadeira e, caso contrario, lanca uma excecao
	 * com a mensagem a ser apresentada.
	 * 
	 * @param expression
	 *            condicao a ser verificada quanto sua afirmacao (true).
	 * @param message
	 *            mensagem a ser exibida.
	 */
	public static void isTrue(Boolean expression, String message) {
		org.springframework.util.Assert.isTrue(expression, message);
	}

	/**
	 * Verifica se o objeto passado como parametro e nulo e, caso contrario
	 * lanca a excecao parametrizada.
	 * 
	 * @param value
	 *            Objeto a ser verificado se eh nulo.
	 * @param exceptionToLaunch
	 *            RuntimeExcetpion a ser lancada caso o objeto nao seja nulo.
	 */
	public static void isNull(Object value, RuntimeException exceptionToLaunch) {
		try {
			org.springframework.util.Assert.isNull(value);
		} catch (Exception e) {
			throw exceptionToLaunch;
		}
	}

	/**
	 * Verifica se o objeto e nulo e, caso negativo, e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param object
	 *            Objeto a ser verificado quanto sua referencia (nula).
	 */
	public static void isNull(Object object) {
		org.springframework.util.Assert.isNull(object);
	}

	/**
	 * Verifica se o objeto e nulo e, caso negativo, e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param object
	 *            Objeto a ser verificado quanto sua referencia (nula).
	 * @param message
	 *            Mensagem a ser exibida quando ocorrer o lancamento da excecao.
	 */
	public static void isNull(Object object, String message) {
		org.springframework.util.Assert.isNull(object, message);
	}

	/**
	 * Verifica se o objeto nao e nulo e, caso negativo, e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param object
	 *            Objeto a ser verificado quanto sua referencia (nula).
	 * @param message
	 *            Mensagem a ser exibida quando ocorrer o lancamento da excecao.
	 */
	public static void notNull(Object object, String message) {
		org.springframework.util.Assert.notNull(object, message);
	}

	/**
	 * Verifica se o objeto nao e nulo e, caso negativo, e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param object
	 *            Objeto a ser verificado quanto sua referencia (nula).
	 */
	public static void notNull(Object object) {
		org.springframework.util.Assert.notNull(object);
	}

	/**
	 * Verifica se o objeto nao e nulo e, caso negativo, e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param object
	 *            Objeto a ser verificado quanto sua referencia (nula).
	 * @param exceptionToLaunch
	 *            {@link RuntimeException} a ser lancada caso a assertiva seja
	 *            false.
	 */
	public static void notNull(Object object, RuntimeException exceptionToLaunch) {
		try {
			org.springframework.util.Assert.notNull(object);
		} catch (Exception e) {
			throw exceptionToLaunch;
		}
	}

	/**
	 * Verifica se a Collection nao eh vazia nem nula. Caso seja eh lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param collection
	 *            Colecao a ser verificada quanto seu preenchimento e
	 *            referencia.
	 */
	public static void notEmpty(Collection<?> collection) {
		org.springframework.util.Assert.notEmpty(collection);
	}

	/**
	 * Verifica se a Collection é vazia ou nula. Caso não seja eh lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param collection
	 *            Colecao a ser verificada quanto seu preenchimento e
	 *            referencia.
	 */
	public static void isEmpty(Collection<?> collection) {
		if (collection != null && !collection.isEmpty()) {
			throw new IllegalArgumentException(
					"Coleção nao nula e preenchida com objetos");
		}
	}

	/**
	 * Verifica se a Collection é vazia ou nula. Caso não seja eh lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param collection
	 *            Colecao a ser verificada quanto seu preenchimento e
	 *            referencia.
	 * @param runtimeException
	 *            Exceção a ser lançada no caso da assertiva ser falsa.
	 */
	public static void isEmpty(Collection<?> collection,
			RuntimeException runtimeException) {
		try {
			isEmpty(collection);
		} catch (IllegalArgumentException e) {
			throw runtimeException;
		}
	}

	/**
	 * Verifica se a Collection nao eh vazia nem nula. Caso seja eh lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param collection
	 *            Colecao a ser verificada quanto seu preenchimento e
	 *            referencia.
	 * @param message
	 *            Mensagem a ser exibida como texto da excecao.
	 */
	public static void notEmpty(Collection<?> collection, String message) {
		org.springframework.util.Assert.notEmpty(collection, message);
	}

	/**
	 * Verifica se a Collection nao eh vazia nem nula. Caso seja eh lancada uma
	 * {@link RuntimeException}.
	 * 
	 * @param collection
	 *            Colecao a ser verificada quanto seu preenchimento e
	 *            referencia.
	 * @param exceptionToLaunch
	 *            RuntimeException a ser lancada qundo a assertiva for nula.
	 */
	public static void notEmpty(Collection<?> collection,
			RuntimeException exceptionToLaunch) {
		try {
			org.springframework.util.Assert.notEmpty(collection);
		} catch (Exception e) {
			throw exceptionToLaunch;
		}
	}

	/**
	 * Verifica se o Map nao esta vazio nem eh nulo. Caso falso e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param map
	 *            Map a ser verificado quanto ao seu preenchimento quanto
	 *            referencia.
	 */
	public static void notEmpty(Map<?, ?> map) {
		org.springframework.util.Assert.notEmpty(map);
	}

	/**
	 * Verifica se o Map nao esta vazio nem eh nulo. Caso falso e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param map
	 *            Map a ser verificado quanto ao seu preenchimento quanto
	 *            referencia.
	 * @param message
	 *            Mensagem a ser exibida pela excecao lancada.
	 */
	public static void notEmpty(Map<?, ?> map, String message) {
		org.springframework.util.Assert.notEmpty(map);
	}

	/**
	 * Verifica se o Map nao esta vazio nem eh nulo. Caso falso e lancada uma
	 * {@link IllegalArgumentException}.
	 * 
	 * @param map
	 *            Map a ser verificado quanto ao seu preenchimento quanto
	 *            referencia.
	 * @param exceptionToLaunch
	 *            {@link RuntimeException} a ser lancada caso a assertiva seja
	 *            false.
	 */
	public static void notEmpty(Map<?, ?> map,
			RuntimeException exceptionToLaunch) {
		try {
			org.springframework.util.Assert.notEmpty(map);
		} catch (Exception e) {
			throw exceptionToLaunch;
		}
	}

	/**
	 * Verifica se a String esta preenchida com valores diferentes de espaco em
	 * branco, se o length e maior que 0 e diferente de nulo. Caso a assertiva
	 * seja false eh lancada uma {@link IllegalArgumentException}.
	 * 
	 * @param text
	 *            String a ser verificada quanto seu preenchimento.
	 */
	public static void hasText(String text) {
		org.springframework.util.Assert.hasText(text);
	}

	/**
	 * Verifica se a String esta preenchida com valores diferentes de espaco em
	 * branco, se o length e maior que 0 e diferente de nulo. Caso a assertiva
	 * seja false eh lancada uma {@link IllegalArgumentException}.
	 * 
	 * @param text
	 *            String a ser verificada quanto seu preenchimento.
	 * @param message
	 *            Mensagem a ser exibida caso seja lancada uma Excecao.
	 */
	public static void hasText(String text, String message) {
		org.springframework.util.Assert.hasText(text);
	}

	/**
	 * Verifica se a String esta preenchida com valores diferentes de espaco em
	 * branco, se o length e maior que 0 e diferente de nulo. Caso a assertiva
	 * seja false eh lancada uma {@link RuntimeException}.
	 * 
	 * @param text
	 *            String a ser verificada quanto seu preenchimento.
	 * @param exceptionToLaunch
	 *            {@link RuntimeException} a ser lancada caso a assertiva seja
	 *            false.
	 */
	public static void hasText(String text, RuntimeException exceptionToLaunch) {
		try {
			org.springframework.util.Assert.hasText(text);
		} catch (Exception e) {
			throw exceptionToLaunch;
		}
	}

}
